package service;
import domain.dto.*;
import domain.entity.*;
import domain.vo.*;
import java.util.*;

public class UserService {
    /**
 * 实体对象的最⼤存储量
 * 表示系统最多可以存储的⽤户实体对象数量
 */
public static int DATA_SIZE = 100;
/**
 * ⽤于存储实体对象的数组
 * 数组的⼤⼩为 DATA_SIZE + 1，⽤于存储⽤户实体对象
 */
public static User[] data = new User[DATA_SIZE + 1];
/**
 * ID 计数器，⽤于为新创建的⽤户分配唯⼀的 ID
 * 从 1 开始递增，确保每个新创建的⽤户都有⼀个唯⼀的标识
 */
public static int idCounter = 1;
/**
 * 根据⽤户传输对象（UserDto）和⽤户 ID 创建⼀个新的⽤户实体对象（User）。
 *
 * @param dto 传⼊的⽤户传输对象，包含⽤户的基本信息
 * @param id 为新创建的⽤户实体指定的唯⼀ ID
 * @return 返回创建好的⽤户实体对象
 */
public static User createEntity(UserDto dto, int id) {
    // 使⽤传⼊的⽤户传输对象（UserDto）中的信息创建⼀个新的⽤户实体对象（User）
    User user = new User(dto.username, dto.name, dto.mobile, dto.email, dto.deptId, dto.roleId);
    // 为新创建的⽤户实体对象分配唯⼀的 ID
    user.id = id;
    // 返回创建好的⽤户实体对象
    return user;
}
/**
 * 根据⽤户传输对象（UserDto）更新⽤户实体对象（User）的属性值。
 *
 * @param dto 传⼊的⽤户传输对象，包含需要更新的⽤户信息
 * @param user 需要更新的⽤户实体对象
 */
public static void updateEntity(UserDto dto, User user) {
    // 使⽤传⼊的⽤户传输对象（UserDto）更新⽤户实体对象的属性
    user.username = dto.username;
    user.name = dto.name;
    user.mobile = dto.mobile;
    user.email = dto.email;
    user.deptId = dto.deptId;
    user.roleId = dto.roleId;
}

    public static Result create(UserDto dto) {
        // 检查是否超出存储容量
        if (idCounter > DATA_SIZE) {
            // 如果存储容量超出限制，返回失败结果
            return Result.failure("创建失败，超出存储容量");
        }
        // 验证部⻔ ID 是否存在
        if (!DeptService.existsById(dto.deptId)) {
            // 如果指定的部⻔ ID 不存在，返回失败结果
            return Result.failure("创建失败，不存在该部⻔");
        }
        // 验证⻆⾊ ID 是否存在
        if (!RoleService.existsById(dto.roleId)) {
            // 如果指定的⻆⾊ ID 不存在，返回失败结果
            return Result.failure("创建失败，不存在该⻆⾊");
        }
        // 创建新的 User 对象
        User user = createEntity(dto, idCounter++);
        // 将新创建的⽤户实体对象存储到数组中
        data[user.id] = user;
        // 返回成功结果，并携带创建成功的⽤户数据
        return Result.success("创建成功", user);
    }

    public static UserVo convertToVo(User user) {
        // 查找部⻔名称
        String deptName = "";
        // 调⽤ DeptService 的 findById ⽅法，根据⽤户的部⻔ ID 查找部⻔信息
        Dept dept = DeptService.findById(user.deptId);
        if (dept != null) {
            // 如果找到部⻔信息，将部⻔名称赋值给 deptName
            deptName = dept.name;
        }
        // 查找⻆⾊名称
        String roleName = "";
        // 调⽤ RoleService 的 findById ⽅法，根据⽤户的⻆⾊ ID 查找⻆⾊信息
        Role role = RoleService.findById(user.roleId);
        if (role != null) {
            // 如果找到⻆⾊信息，将⻆⾊名称赋值给 roleName
            roleName = role.name;
        }
        // 创建并返回 UserVo 对象
        return new UserVo(user.id, user.username, user.name, user.mobile,
                user.email,
                user.deptId, user.roleId, user.enabled, deptName, roleName);
    }

    public static Result list() {
        // 创建⼀个临时数组，⽤于存储有效的⽤户数据，数组⼤⼩为 DATA_SIZE
        UserVo[] temp = new UserVo[DATA_SIZE];
        // ⽤于记录临时数组的实际存储⻓度
        int length = 0;
        // 遍历存储⽤户的原始数据数组，从下标 1 开始，到 idCounter - 1 结束
        for (int i = 1; i < idCounter; i++) {
            // 如果当前⽤户数据不为空，则将其添加到临时数组中
            if (data[i] != null) {
                // 调⽤ convertToVo ⽅法将 User 对象转换为 UserVo 对象，并添加到临时数组中
                temp[length++] = convertToVo(data[i]);
            }
        }
        // 返回查询成功的结果，并返回临时数组的有效部分
        return Result.success("查询成功", Arrays.copyOf(temp, length));
    }

    public static Result update(UserDto dto, int id) {
        // 验证⽤户 ID 是否有效
        if (id < 1 || id >= idCounter || data[id] == null) {
            // 如果 ID ⽆效，返回失败结果
            return Result.failure("更新失败，不存在该数据");
        }
        // 验证部⻔ ID 是否存在
        if (!UserService.existsById(dto.deptId)) {
            // 如果指定的部⻔ ID 不存在，返回失败结果
            return Result.failure("更新失败，不存在该部⻔");
        }
        // 验证⻆⾊ ID 是否存在
        if (!RoleService.existsById(dto.roleId)) {
            // 如果指定的⻆⾊ ID 不存在，返回失败结果
            return Result.failure("更新失败，不存在该⻆⾊");
        }
        // 获取指定 ID 的⽤户对象
        User user = data[id];
        // 更新⽤户信息
        updateEntity(dto, user);
        // 返回成功结果，更新完成
        return Result.success("更新成功", null);
    }

    public static boolean deptInUse(int deptId) {
        boolean inUse = false;
        // 遍历存储⽤户数据的数组
        for (User user : data) {
            // 检查⽤户是否存在且该⽤户的部⻔ ID 等于传⼊的部⻔ ID
            if (user != null && user.deptId == deptId) {
                inUse = true;
                break;
            }
        }
        return inUse;
    }

    public static boolean roleInUse(int roleId) {
        boolean inUse = false;
        // 遍历存储⽤户数据的数组
        for (User user : data) {
            // 检查⽤户是否存在且该⽤户的⻆⾊ ID 等于传⼊的⻆⾊ ID
            if (user != null && user.roleId == roleId) {
                inUse = true;
                break;
            }
        }
        return inUse;
    }

    public static boolean existsById(int id) {
        return id >= 1 && id < idCounter && data[id] != null;
    }

    public static Result toggle(int id) {
        // 检查 ID 是否有效
        if (id < 1 || id >= idCounter || data[id] == null) {
            return Result.failure("切换状态失败，不存在该数据");
        }
        // 反转 `enabled` 状态
        data[id].enabled = !data[id].enabled;
        // 根据新的状态返回不同的成功消息
        return Result.success(data[id].enabled ? "启⽤成功" : "禁⽤成功",
                null);
    }
}
